{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note: This example is compatible with versions v0.2.1dev or higher (i.e., up to date with GitHub). For instructions on how to run with latest pip stable versions (<=v0.1.5), see [this](https://github.com/facebookresearch/mbrl-lib/blob/main/notebooks/pets_example_v0.1.5.ipynb) notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preview\n",
    "\n",
    "In this example, we are going to use our toolbox to write the [PETS](https://arxiv.org/pdf/1805.12114.pdf) algorithm (Chua at al., 2018), and use it to solve a continuous version of the cartpole environment. PETS is a model-based algorithm that consists of two main components: an ensemble of probabilistic models (each a feed-forward neural network), and a planner using the [Cross-Entropy Method](https://people.smp.uq.edu.au/DirkKroese/ps/aortut.pdf) (de Boer et al., 2004). \n",
    "\n",
    "A basic implementation of this algorithm consists of the following sequence of steps:\n",
    "\n",
    "1. Gather data using an exploration policy\n",
    "2. Repeat:<br>\n",
    "  2.1. Train the dynamics model using all available data.<br>\n",
    "  2.2. Do a trajectory on the environment, choosing actions with the planner, using the dynamics model to simulate environment transitions.\n",
    "  \n",
    "The ensemble model is trained to predict the environment's dynamics, and the planner tries to find high-reward trajectories over the model dynamics. \n",
    "\n",
    "To implement this using `MBRL-Lib`, we will use an ensemble of neural networks (NNs) modelling Gaussian distributions (available in the [mbrl.models](https://luisenp.github.io/mbrl-lib/models.html#mbrl.models.GaussianMLP) module), and a trajectory optimizer agent that uses CEM (available in the [mbrl.planning](https://luisenp.github.io/mbrl-lib/planning.html#mbrl.planning.TrajectoryOptimizerAgent) module). We will also rely on several of the utilities available in the [mbrl.util](https://luisenp.github.io/mbrl-lib/util.html) module. Finally, we will wrap the dynamics model into a [gym-like environment](https://luisenp.github.io/mbrl-lib/models.html#mbrl.models.ModelEnv) over which we can plan action sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython import display\n",
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import omegaconf\n",
    "\n",
    "import mbrl.env.cartpole_continuous as cartpole_env\n",
    "import mbrl.env.reward_fns as reward_fns\n",
    "import mbrl.env.termination_fns as termination_fns\n",
    "import mbrl.models as models\n",
    "import mbrl.planning as planning\n",
    "import mbrl.util.common as common_util\n",
    "import mbrl.util as util\n",
    "\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "mpl.rcParams.update({\"font.size\": 16})\n",
    "\n",
    "device = 'cuda:0' if torch.cuda.is_available() else 'cpu'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the environment\n",
    "\n",
    "First we instantiate the environment and specify which reward function and termination function to use with the gym-like environment wrapper, along with some utility objects. The termination function tells the wrapper if an observation should cause an episode to end or not, and it is an input used in some algorithms, like [MBPO](https://github.com/JannerM/mbpo/blob/master/mbpo/static/halfcheetah.py). The reward function is used to compute the value of the reward given an observation, and it's used by some algorithms, like [PETS](https://github.com/kchua/handful-of-trials/blob/77fd8802cc30b7683f0227c90527b5414c0df34c/dmbrl/controllers/MPC.py#L65)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 0\n",
    "env = cartpole_env.CartPoleEnv(render_mode=\"rgb_array\")\n",
    "env.reset(seed)\n",
    "rng = np.random.default_rng(seed=0)\n",
    "generator = torch.Generator(device=device)\n",
    "generator.manual_seed(seed)\n",
    "obs_shape = env.observation_space.shape\n",
    "act_shape = env.action_space.shape\n",
    "\n",
    "# This functions allows the model to evaluate the true rewards given an observation \n",
    "reward_fn = reward_fns.cartpole\n",
    "# This function allows the model to know if an observation should make the episode end\n",
    "term_fn = termination_fns.cartpole"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hydra configuration\n",
    "\n",
    "MBRL-Lib uses [Hydra](https://github.com/facebookresearch/hydra) to manage configurations. For the purpose of this example, you can think of the configuration object as a dictionary with key/value pairs--and equivalent attributes--that specify the model and algorithmic options. Our toolbox expects the configuration object to be organized as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "trial_length = 200\n",
    "num_trials = 10\n",
    "ensemble_size = 5\n",
    "\n",
    "# Everything with \"???\" indicates an option with a missing value.\n",
    "# Our utility functions will fill in these details using the \n",
    "# environment information\n",
    "cfg_dict = {\n",
    "    # dynamics model configuration\n",
    "    \"dynamics_model\": {\n",
    "        \"_target_\": \"mbrl.models.GaussianMLP\",\n",
    "        \"device\": device,\n",
    "        \"num_layers\": 3,\n",
    "        \"ensemble_size\": ensemble_size,\n",
    "        \"hid_size\": 200,\n",
    "        \"in_size\": \"???\",\n",
    "        \"out_size\": \"???\",\n",
    "        \"deterministic\": False,\n",
    "        \"propagation_method\": \"fixed_model\",\n",
    "        # can also configure activation function for GaussianMLP\n",
    "        \"activation_fn_cfg\": {\n",
    "            \"_target_\": \"torch.nn.LeakyReLU\",\n",
    "            \"negative_slope\": 0.01\n",
    "        }\n",
    "    },\n",
    "    # options for training the dynamics model\n",
    "    \"algorithm\": {\n",
    "        \"learned_rewards\": False,\n",
    "        \"target_is_delta\": True,\n",
    "        \"normalize\": True,\n",
    "    },\n",
    "    # these are experiment specific options\n",
    "    \"overrides\": {\n",
    "        \"trial_length\": trial_length,\n",
    "        \"num_steps\": num_trials * trial_length,\n",
    "        \"model_batch_size\": 32,\n",
    "        \"validation_ratio\": 0.05\n",
    "    }\n",
    "}\n",
    "cfg = omegaconf.OmegaConf.create(cfg_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\"><b>Note: </b> This example uses a probabilistic ensemble. You can also use a fully deterministic model with class GaussianMLP by setting ensemble_size=1, and deterministic=True. </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a dynamics model\n",
    "\n",
    "Given the configuration above, the following two lines of code create a wrapper for 1-D transition reward models, and a gym-like environment that wraps it, which we can use for simulating the real environment. The 1-D model wrapper takes care of creating input/output data tensors to the underlying NN model (by concatenating observations, actions and rewards appropriately), normalizing the input data to the model, and other data processing tasks (e.g., converting observation targets to deltas with respect to the input observation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 1-D dynamics model for this environment\n",
    "dynamics_model = common_util.create_one_dim_tr_model(cfg, obs_shape, act_shape)\n",
    "\n",
    "# Create a gym-like environment to encapsulate the model\n",
    "model_env = models.ModelEnv(env, dynamics_model, term_fn, reward_fn, generator=generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create a replay buffer\n",
    "\n",
    "We can create a replay buffer for this environment an configuration using the following method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "replay_buffer = common_util.create_replay_buffer(cfg, obs_shape, act_shape, rng=rng)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now populate the replay buffer with random trajectories of a desired length, using a single function call to `util.rollout_agent_trajectories`. Note that we pass an agent of type `planning.RandomAgent` to generate the actions; however, this method accepts any agent that is a subclass of `planning.Agent`, allowing changing exploration strategies with minimal changes to the code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# samples stored 200\n"
     ]
    }
   ],
   "source": [
    "common_util.rollout_agent_trajectories(\n",
    "    env,\n",
    "    trial_length, # initial exploration steps\n",
    "    planning.RandomAgent(env),\n",
    "    {}, # keyword arguments to pass to agent.act()\n",
    "    replay_buffer=replay_buffer,\n",
    "    trial_length=trial_length\n",
    ")\n",
    "\n",
    "print(\"# samples stored\", replay_buffer.num_stored)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CEM Agent\n",
    "\n",
    "The following config object and the subsequent function call create an agent that can plan using the Cross-Entropy Method over the model environment created above. When calling `planning.create_trajectory_optim_agent_for_model`, we also specify how many particles to use when propagating model uncertainty, as well as the uncertainty propagation method, \"fixed_model\", which corresponds to the method TS$\\infty$ in the PETS paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent_cfg = omegaconf.OmegaConf.create({\n",
    "    # this class evaluates many trajectories and picks the best one\n",
    "    \"_target_\": \"mbrl.planning.TrajectoryOptimizerAgent\",\n",
    "    \"planning_horizon\": 15,\n",
    "    \"replan_freq\": 1,\n",
    "    \"verbose\": False,\n",
    "    \"action_lb\": \"???\",\n",
    "    \"action_ub\": \"???\",\n",
    "    # this is the optimizer to generate and choose a trajectory\n",
    "    \"optimizer_cfg\": {\n",
    "        \"_target_\": \"mbrl.planning.CEMOptimizer\",\n",
    "        \"num_iterations\": 5,\n",
    "        \"elite_ratio\": 0.1,\n",
    "        \"population_size\": 500,\n",
    "        \"alpha\": 0.1,\n",
    "        \"device\": device,\n",
    "        \"lower_bound\": \"???\",\n",
    "        \"upper_bound\": \"???\",\n",
    "        \"return_mean_elites\": True,\n",
    "        \"clipped_normal\": False\n",
    "    }\n",
    "})\n",
    "\n",
    "agent = planning.create_trajectory_optim_agent_for_model(\n",
    "    model_env,\n",
    "    agent_cfg,\n",
    "    num_particles=20\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running PETS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Having a model and an agent, we can now run PETS with a simple loop and a few function calls. The first code block creates a callback to pass to the model trainer to accumulate the training losses and validation scores observed. The second block is just a utility function to update the agent's visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_losses = []\n",
    "val_scores = []\n",
    "\n",
    "def train_callback(_model, _total_calls, _epoch, tr_loss, val_score, _best_val):\n",
    "    train_losses.append(tr_loss)\n",
    "    val_scores.append(val_score.mean().item())   # this returns val score per ensemble model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_axes(_axs, _frame, _text, _trial, _steps_trial, _all_rewards, force_update=False):\n",
    "    if not force_update and (_steps_trial % 10 != 0):\n",
    "        return\n",
    "    _axs[0].imshow(_frame)\n",
    "    _axs[0].set_xticks([])\n",
    "    _axs[0].set_yticks([])\n",
    "    _axs[1].clear()\n",
    "    _axs[1].set_xlim([0, num_trials + .1])\n",
    "    _axs[1].set_ylim([0, 200])\n",
    "    _axs[1].set_xlabel(\"Trial\")\n",
    "    _axs[1].set_ylabel(\"Trial reward\")\n",
    "    _axs[1].plot(_all_rewards, 'bs-')\n",
    "    _text.set_text(f\"Trial {_trial + 1}: {_steps_trial} steps\")\n",
    "    display.display(plt.gcf())  \n",
    "    display.clear_output(wait=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following lines implement the PETS algorithm. First, we create a model trainer and pass some hyperparameters for the optimizer (Adam), along with references to the model instance to use. Then we start a loop where we execute actions of ``agent`` in the environment and train the model at the beginning of the episode (by calling ``model_trainer.train()``. At every step in the loop, we execute an agent action in the environment and populate the replay buffer by calling ``util.step_env_and_add_to_buffer()``. Importantly, at the beginning of each episode we also call ``agent.reset()`` to clear any episode dependent cache; in the case of a ``TrajectoryOptimizerAgent``, this means clearing the previous action sequence found, which is shifted at every call to obtain an initial solution for the optimizer. \n",
    "\n",
    "The rest of the code is mostly bookkeeping to keep track of the total reward observed during each episode, and to make sure episodes terminate after some desired length. After running this code, you should see the agent reaching the maximum reward of 200 after a few episodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1400x375 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a trainer for the model\n",
    "model_trainer = models.ModelTrainer(dynamics_model, optim_lr=1e-3, weight_decay=5e-5)\n",
    "\n",
    "# Create visualization objects\n",
    "fig, axs = plt.subplots(1, 2, figsize=(14, 3.75), gridspec_kw={\"width_ratios\": [1, 1]})\n",
    "ax_text = axs[0].text(300, 50, \"\")\n",
    "    \n",
    "# Main PETS loop\n",
    "all_rewards = [0]\n",
    "for trial in range(num_trials):\n",
    "    obs, _ = env.reset(None)    \n",
    "    agent.reset()\n",
    "    \n",
    "    terminated = False\n",
    "    total_reward = 0.0\n",
    "    steps_trial = 0\n",
    "    update_axes(axs, env.render(), ax_text, trial, steps_trial, all_rewards)\n",
    "    while not terminated:\n",
    "        # --------------- Model Training -----------------\n",
    "        if steps_trial == 0:\n",
    "            dynamics_model.update_normalizer(replay_buffer.get_all())  # update normalizer stats\n",
    "            \n",
    "            dataset_train, dataset_val = common_util.get_basic_buffer_iterators(\n",
    "                replay_buffer,\n",
    "                batch_size=cfg.overrides.model_batch_size,\n",
    "                val_ratio=cfg.overrides.validation_ratio,\n",
    "                ensemble_size=ensemble_size,\n",
    "                shuffle_each_epoch=True,\n",
    "                bootstrap_permutes=False,  # build bootstrap dataset using sampling with replacement\n",
    "            )\n",
    "                \n",
    "            model_trainer.train(\n",
    "                dataset_train, \n",
    "                dataset_val=dataset_val, \n",
    "                num_epochs=50, \n",
    "                patience=50, \n",
    "                callback=train_callback,\n",
    "                silent=True)\n",
    "\n",
    "        # --- Doing env step using the agent and adding to model dataset ---\n",
    "        next_obs, reward, terminated, truncated, _ = common_util.step_env_and_add_to_buffer(\n",
    "            env, obs, agent, {}, replay_buffer)\n",
    "            \n",
    "        update_axes(\n",
    "            axs, env.render(), ax_text, trial, steps_trial, all_rewards)\n",
    "        \n",
    "        obs = next_obs\n",
    "        total_reward += reward\n",
    "        steps_trial += 1\n",
    "        \n",
    "        if steps_trial == trial_length:\n",
    "            break\n",
    "    \n",
    "    all_rewards.append(total_reward)\n",
    "\n",
    "update_axes(axs, env.render(), ax_text, trial, steps_trial, all_rewards, force_update=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, below we check the results of the trainer callback, which show the training loss and validation score across all calls to ``model_trainer.train()``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, 1, figsize=(12, 10))\n",
    "ax[0].plot(train_losses)\n",
    "ax[0].set_xlabel(\"Total training epochs\")\n",
    "ax[0].set_ylabel(\"Training loss (avg. NLL)\")\n",
    "ax[1].plot(val_scores)\n",
    "ax[1].set_xlabel(\"Total training epochs\")\n",
    "ax[1].set_ylabel(\"Validation score (avg. MSE)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Where to learn more about MBRL?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To learn about the other features of the library, please check out our [documentation](https://facebookresearch.github.io/mbrl-lib/). Also take a look at our provided implementations of [PETS](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/pets.py), [MBPO](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/mbpo.py), and [PlaNet](https://github.com/facebookresearch/mbrl-lib/blob/main/mbrl/algorithms/planet.py), and their configuration [files](https://github.com/facebookresearch/mbrl-lib/tree/main/mbrl/examples/conf)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mbrl",
   "language": "python",
   "name": "mbrl"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
